################################
# PARTIE II : Jeu des Lemmings #
################################
class Jeu():
    """Classe globale gérant le jeu des Lemmings. Cette classe s'appuie sur
       les classes Lemming et Case et fournit les méthodes pour gérer le jeu
       (initialisation, affichage, tour de jeu, ... """
    def __init__(self, nom_fichier_grotte:str):
        # TODO

    def affiche(self):
        """Permet d'afficher la grille de jeu en mode texte (on s'appuie sur
           la méthode __str__ ou __repr__ de la classe Case)."""
        # TODO
    
    def tour(self):
        """Active les lemmings les uns après les autres dans l'ordre de leur
           apparition en utilisant leur méthode action()."""
        # TODO
    
    def demarre(self):
        """Lance et gère une partie du jeu des Lemmings."""
        # TODO

    def _lecture_fichier_grotte(self, nom_fichier_grotte:str) -> list:
        """Renvoie un tableau à deux dimensions d'objets Case initialisées en
           suivant la représentation du fichier texte fourni en argument."""
        with open(nom_fichier_grotte, "r") as fichier:
            return [[Case(c) for c in ligne if c != '\n'] \
                    for ligne in fichier.readlines() ]

class Lemming():
    """Classe permettant de gérer un lemming : affichage, déplacement,
       suppression. Cette classe s'appuie sur la classe Jeu (pour récupérer la
       grille de jeu afin de connaitre l'environnement du lemming) et Case (
       pour se déplacer d'une case à l'autre et savoir quand une case est
       libre)."""
    def __init__(self, jeu:Jeu, l:int, c:int):
        """Crée un objet lemming dans la case de coordonnées l (ligne) et
           c (colonne). On fournit aussi l'objet jeu (en premier argument)
           pour que le lemming puisse utiliser la grille de jeu."""
        # TODO

    def __str__(self) -> str:
        """Renvoie le caractère '<' ou '>' suivant la direction actuelle du
           lemming."""
        # TODO

    def _deplacement(self, l_arrivee:int, c_arrivee:int) -> bool:
        """Teste si la case dont les coordonnées sont fournie est libre et
           opére le déplacement du lemming (en utilisant les fonctions depart()
           et arrivee() de la classe Case) si c'est le cas puis renvoie True.
           Renvoie False si le déplacement n'est pas possible."""
        # TODO

    def action(self):
        """Gére le mouvement du lemming :
           . si la case en dessous est vide, le lemming tombe dedans
           . sinon si la case en face de lui est vide, il y va
           . sinon dans les autres cas, le lemming reste sur place mais change
             de direction
           On s'appuie sur la fonction interne _deplacement(l, c) pour
           simplifier l'écriture."""
        # TODO
    
    def sort(self):
        """Retire ce lemming de la liste des lemmings en jeu fournie par la
           classe Jeu."""
        # TODO

class Case():
    """Classe gérant les cases de la grotte dans le jeu des Lemmings. Cette
       classe s'appuie sur la classe Lemming et gère l'affichage de la case
       (grâce à la méthode __str__) ainsi que la présence, entrée ou sortie
       d'un éventuel lemming. Elle fournie la méthode libre qui renseigne les
       lemming lors de leurs déplacement."""
    def __init__(self, caractere:str):
        """Crée un objet case initialisé avec le caractère donné en argument."""
        # TODO
    
    def __str__(self) -> str:
        """Renvoie le caractère représentant la case ou bien celui représentant
           le lemming qu'elle contient (en appelant la méthode str du lemming).
           """
        # TODO
    
    def libre(self) -> bool:
        """Renvoie True si la case n'est pas un mur et qu'elle ne contient pas
           de lemming et False sinon."""
        # TODO
    
    def depart(self):
        """Supprime le lemming de la case en indiquant qu'il n'y en a plus."""
        # TODO
    
    def arrivee(self, lem:Lemming):
        """Place le lemming lem donné en argument dans la case ou bien le fait
           sortir si la case est une sortie."""
        # TODO

j = Jeu("grotte.txt")
j.demarre()